const express = require('express');
const router = express.Router();
const Product = require('../models/Product');
const InboundOrder = require('../models/InboundOrder');
const OutboundOrder = require('../models/OutboundOrder');
const PurchaseOrder = require('../models/PurchaseOrder');  // Fixed import (uppercase 'P' in path and variable)
const mongoose = require('mongoose');
const { authenticate } = require('../middlewares/auth');
// 1. 创建商品（创建新商品并标记为上架中）
router.post('/products/online',authenticate, async (req, res) => {
  try {
    const { name, category, currentStock, description, price } = req.body;
    // 校验必填字段（根据业务需求调整）
    if (!name || !category || !currentStock) {
      return res.status(400).json({ message: '缺少必填字段（name, category, currentStock）' });
    }

    // 新增：校验商品名称唯一性
    const existingProduct = await Product.findOne({ name });
    if (existingProduct) {
      return res.status(400).json({ message: '该商品名称已存在，请勿重复上架' });
    }

    // 创建新商品并自动设置状态为"上架中"
    const newProduct = await Product.create({
      name,
      category,
      currentStock,
      description,
      price,
      status: '上架中'  // 自动标记为上架状态
    });

    res.status(201).json({ message: '商品上架成功（已创建）', product: newProduct });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
// 下架商品   ok
router.put('/products/:id/offline', authenticate, async (req, res) => {
  try {
    const product = await Product.findByIdAndUpdate(
      req.params.id,
      { status: '下架中' },  // 修改为下架状态
      { new: true }  // 返回更新后的文档
    );
    if (!product) return res.status(404).json({ message: '商品不存在' });
    res.json(product);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
// 更改商品信息     ok
router.put('/products/:id', authenticate, async (req, res) => {
  try {
    const { name, category, currentStock, description, price } = req.body;
    const product = await Product.findByIdAndUpdate(
      req.params.id,
      { name, category, currentStock, description, price },  // 更新传入的字段
      { new: true, runValidators: true }  // 启用验证规则（如库存最小值）
    );
    if (!product) return res.status(404).json({ message: '商品不存在' });
    res.json(product);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
// 查询商品列表  ok
router.get('/products', authenticate, async (req, res) => {
  const products = await Product.find().sort({ createdAt: -1 });  // 按创建时间降序排列（最新在前）
  res.json(products);
});
// 10. 查询单个商品信息
router.get('/products/:id', authenticate, async (req, res) => {
  try {
    const product = await Product.findById(req.params.id);
    if (!product) return res.status(404).json({ message: '商品不存在' });
    res.json(product);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
// 新增：商品重新上架接口（将"下架中"商品改为"上架中"）
router.put('/products/:id/online',authenticate,  async (req, res) => {
  try {
    const product = await Product.findById(req.params.id);
    // 校验商品是否存在
    if (!product) {
      return res.status(404).json({ message: '商品不存在' });
    }
    // 校验当前状态是否为"下架中"
    if (product.status !== '下架中') {
      return res.status(400).json({ message: '仅允许重新上架状态为"下架中"的商品' });
    }

    // 更新状态为"上架中"
    product.status = '上架中';
    await product.save();

    res.json({ message: '商品重新上架成功', product });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});


// 新增：入库订单审核不通过
router.put('/inbound-orders/:id/reject', authenticate, async (req, res) => {
  try {
    const order = await InboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '入库订单不存在' });
    if (order.status !== '待审核') {
      return res.status(400).json({ message: '仅允许审核待审核的入库订单' });
    }

    // 更新状态为"审核不通过"
    order.status = '审核不通过';
    await order.save();

    res.json({ message: '入库订单审核不通过', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// ---------------- 新增接口 ----------------

// 6. 入库（创建入库订单）
router.post('/inbound-orders',authenticate,  async (req, res) => {
  try {
    const { productId, productName, quantity, supplier } = req.body;
    // 校验商品存在
    const product = await Product.findById(productId);
    if (!product) return res.status(404).json({ message: '商品不存在' });
    console.log(product);
    
    // 创建入库订单（状态默认"待审核"）
    const newOrder = new InboundOrder({
      productId,
      productName,
      quantity,
      supplier
    });
    await newOrder.save();

    res.status(201).json({ message: '入库订单创建成功', order: newOrder });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 7. 出库（创建出库订单）
router.post('/outbound-orders',authenticate,  async (req, res) => {
  try {
    const { productId, productName, quantity, userName, phone, address } = req.body;
    // 校验商品存在且库存足够
    const product = await Product.findById(productId);
    if (!product) return res.status(404).json({ message: '商品不存在' });
    if (product.currentStock < quantity) {
      return res.status(400).json({ message: '库存不足，无法创建出库订单' });
    }
//下架商品无法创建订单
    if (product.status === '下架中') {
      return res.status(400).json({ message: '下架商品无法创建出库订单' });
    }
    // 创建出库订单（状态默认"待审核"）
    const newOrder = new OutboundOrder({
      productId,
      productName,
      quantity,
      userName,
      phone,
      address
    });
    await newOrder.save();

    res.status(201).json({ message: '出库订单创建成功', order: newOrder });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 8. 出库订单审核通过（单个订单）
router.put('/outbound-orders/:id/approve',authenticate,  async (req, res) => {
  try {
    const order = await OutboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '出库订单不存在' });
    if (order.status !== '待审核') {
      return res.status(400).json({ message: '仅允许审核待审核订单' });
    }

    const product = await Product.findById(order.productId);
    if (product.currentStock < order.quantity) {
      return res.status(400).json({ message: '库存不足，无法通过审核' });
    }

    // 修改：待发货 → 待发货审核
    order.status = '待发货审核';
    await order.save();

    res.json(order);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 新增：出库订单审核不通过
router.put('/outbound-orders/:id/reject',authenticate,  async (req, res) => {
  try {
    const order = await OutboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '出库订单不存在' });
    if (order.status !== '待审核') {
      return res.status(400).json({ message: '仅允许审核待审核的出库订单' });
    }

    // 更新状态为"审核不通过"
    order.status = '审核不通过';
    await order.save();

    res.json({ message: '出库订单审核不通过', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 9. 出库订单发货（扣减库存）
router.put('/outbound-orders/:id/deliver',authenticate,  async (req, res) => {
  try {
    const order = await OutboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '出库订单不存在' });
    
    // 修改：校验状态从"待发货"改为"待发货审核"
    if (order.status !== '待发货审核') {
      return res.status(400).json({ message: '仅允许发货状态为"待发货审核"的订单' });
    }

    order.status = '已发货';
    await order.save();

    await Product.findByIdAndUpdate(
      order.productId,
      { $inc: { currentStock: -order.quantity } },
      { runValidators: true }
    );

    res.json({ message: '出库订单发货成功', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});



// 11. 查询入库订单列表（所有）
router.get('/inbound-orders',authenticate,  async (req, res) => {
  try {
    const orders = await InboundOrder.find().sort({ createdAt: -1 });  // 按创建时间降序排列
    res.json(orders);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 12. 查询单个入库订单
router.get('/inbound-orders/:id',authenticate,  async (req, res) => {
  try {
    const order = await InboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '入库订单不存在' });
    res.json(order);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
// 13. 查询出库订单列表（所有）
router.get('/outbound-orders',authenticate,  async (req, res) => {
  try {
    const orders = await OutboundOrder.find().sort({ createdAt: -1 });  // 按创建时间降序排列
    res.json(orders);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 14. 查询单个出库订单
router.get('/outbound-orders/:id',authenticate,  async (req, res) => {
  try {
    const order = await OutboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '出库订单不存在' });
    res.json(order);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// ---------------- 新增采购订单接口 ----------------

// 14. 创建采购订单（状态默认"待审核"）
router.post('/purchase-orders',authenticate,  async (req, res) => {
  try {
    const { area, number, productId, quantity, supplier } = req.body;  // 新增 supplier 解构
    // 校验必填字段（新增 supplier 校验）
    if (!area || !number || !productId || !quantity || !supplier) {
      return res.status(400).json({ message: '缺少必填字段（area, number, productId, quantity, supplier）' });
    }

    // 校验采购订单编号唯一性
    const existingOrder = await PurchaseOrder.findOne({ number });
    if (existingOrder) {
      return res.status(400).json({ message: '采购订单编号已存在' });
    }

    // 校验商品存在
    const product = await Product.findById(productId);
    if (!product) return res.status(404).json({ message: '商品不存在' });

    // 创建采购订单（状态默认"待审核"，新增 supplier 字段）
    const newOrder = await PurchaseOrder.create({
      area,
      number,
      productId,
      quantity,
      supplier,  // 新增供应商参数
      status: '待审核'  // 初始状态
    });

    res.status(201).json({ message: '采购订单创建成功', order: newOrder });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 15. 采购订单审核通过（状态变更为"待采购"）
router.put('/purchase-orders/:id/approve',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    if (order.status !== '待审核') {
      return res.status(400).json({ message: '仅允许审核待审核的采购订单' });
    }

    // 更新状态为"待采购"
    order.status = '待采购';
    await order.save();

    res.json({ message: '采购订单审核通过', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 16. 采购订单审核不通过（状态变更为"审核不通过"）
router.put('/purchase-orders/:id/reject',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    if (order.status !== '待审核') {
      return res.status(400).json({ message: '仅允许审核待审核的采购订单' });
    }

    // 更新状态为"审核不通过"
    order.status = '审核不通过';
    await order.save();

    res.json({ message: '采购订单审核不通过', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 17. 完成采购（状态变更为"采购完成"或"待入库"）
router.put('/purchase-orders/:id/complete',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    if (!['待采购', '采购中'].includes(order.status)) {
      return res.status(400).json({ message: '仅允许完成待采购或采购中的订单' });
    }
    // 校验商品存在
    const product = await Product.findById(order.productId);
    if (!product) return res.status(404).json({ message: '商品不存在' });
    
    // 触发入库流程（新增：传递采购订单ID）
    const inboundOrder = await InboundOrder.create({
      productId: order.productId,
      productName: product.name,
      quantity: order.quantity,
      supplier: order.supplier,
      purchaseOrderId: order._id  // 关联当前采购订单ID
    });

    order.status = '待入库';
    await order.save();

    res.json({ message: '采购完成，已触发入库流程', order, inboundOrder });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 18. 查询采购订单列表（所有）
router.get('/purchase-orders',authenticate,  async (req, res) => {
  try {
    const orders = await PurchaseOrder.find().sort({ createdAt: -1 });  // 按创建时间降序排列
    res.json(orders);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 19. 查询单个采购订单
router.get('/purchase-orders/:id',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    res.json(order);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 新增：入库订单已入库（确认入库并更新库存）
// 合并：入库订单审核通过/确认入库（统一处理两种状态）
router.put('/inbound-orders/:id/approve',authenticate,  async (req, res) => {
  try {
    const order = await InboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '入库订单不存在' });


    if (order.status === '待审核') {
      order.status = '已入库';
      await order.save();

      // 增加商品库存
      await Product.findByIdAndUpdate(
        order.productId,
        { $inc: { currentStock: order.quantity } },
        { runValidators: true }
      );

      // 更新关联的采购订单状态（增强校验）
      let purchaseOrderUpdateResult = null;
      if (order.purchaseOrderId) {
        const purchaseOrder = await PurchaseOrder.findById(order.purchaseOrderId);
        if (purchaseOrder) {
          purchaseOrder.status = '采购完成';
          await purchaseOrder.save();  // 此处可能抛出错误（如状态校验失败）
          purchaseOrderUpdateResult = { 
            purchaseOrderId: purchaseOrder._id,
            status: '采购完成'
          };
        } else {
          purchaseOrderUpdateResult = { 
            error: '关联的采购订单不存在',
            purchaseOrderId: order.purchaseOrderId
          };
        }
      } else {
        purchaseOrderUpdateResult = { 
          error: '入库订单无关联的采购订单ID'
        };
      }

      return res.json({ 
        message: '入库订单确认入库成功', 
        order, 
        purchaseOrderUpdateResult  // 返回采购订单更新结果
      });
    }

    return res.status(400).json({ message: '仅允许处理"待审核"或"待入库"状态的订单' });
  } catch (err) {
    // 捕获采购订单保存时的错误（如状态枚举校验失败）
    res.status(500).json({ message: `处理失败: ${err.message}` });
  }
});

// 新增：取消采购订单（状态变更为"已取消"）
router.put('/purchase-orders/:id/cancel',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    
    // 限制仅未完成状态可取消（根据业务调整允许取消的状态）
    if (!['待审核', '待采购', '采购中', '待入库', '审核不通过'].includes(order.status)) {
      return res.status(400).json({ message: '仅允许取消未完成的采购订单' });
    }

    order.status = '已取消';
    await order.save();

    res.json({ message: '采购订单已取消', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

module.exports = router;

// 新增：重新审核采购订单（审核不通过→待审核）
router.put('/purchase-orders/:id/re-audit',authenticate,  async (req, res) => {
  try {
    const order = await PurchaseOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '采购订单不存在' });
    if (order.status !== '审核不通过'&& order.status!== '入库失败') {
      return res.status(400).json({ message: '仅允许重新审核状态为"审核不通过"的订单' });
    }

    // 重置为待审核状态（可补充其他重置逻辑，如清除历史审核备注）
    order.status = '待审核';
    await order.save();

    res.json({ message: '采购订单已重新提交审核', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});
router.put('/outbound-orders/:id/re-audit',authenticate,  async (req, res) => {
  try {
    const order = await OutboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '出库订单不存在' });
    
    // 校验当前状态是否允许重新审核（仅允许"审核不通过"状态）
    if (!['审核不通过'].includes(order.status)) {
      return res.status(400).json({ message: '仅允许重新审核状态为"审核不通过"的订单' });
    }

    // 重置为待审核状态
    order.status = '待审核';
    await order.save();

    res.json({ message: '出库订单已重新提交审核', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// 新增：入库订单重新进入审核（审核不通过/入库失败→待审核）
router.put('/inbound-orders/:id/re-audit',authenticate,  async (req, res) => {
  try {
    const order = await InboundOrder.findById(req.params.id);
    if (!order) return res.status(404).json({ message: '入库订单不存在' });
    
    // 校验当前状态是否允许重新审核（根据业务需求调整允许的状态）
    if (!['审核不通过', '入库失败'].includes(order.status)) { 
      return res.status(400).json({ message: '仅允许重新审核状态为"审核不通过"或"入库失败"的订单' });
    }

    // 重置为待审核状态
    order.status = '待审核';
    await order.save();

    res.json({ message: '入库订单已重新提交审核', order });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
  
});